package com.gutai.admin.common.util;

import java.math.BigDecimal;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 数字工具类
 */
public class NumberUtil {
    private NumberUtil(){}
    private static final Logger logger = LoggerFactory.getLogger(NumberUtil.class);
    /**
     *
     * @param a 原数据
     * @param scale 指定四舍五入位数
     * @param roundmode 四舍五入规则,BigDecimal.ROUND_HALF_UP
     *    用BigDecimal.ROUND_UP和BigDecimal.ROUND_DOWN来表示上取还是下取
     * @return
     */
    public static Double getRound(Double a,int scale,int roundmode){
        if(a!=null){
            BigDecimal paramnumber=BigDecimal.valueOf(a);
            return paramnumber.setScale(scale,roundmode).doubleValue();
        }
        return null; 
    }

    /**
     * 正则表达式匹配
     * 如果输入为空则返回假
     * @param regexStr
     * @param input
     * @return
     */
    public static boolean regex(String regexStr, String input) {
        if (BlankUtil.isBlank(regexStr) || BlankUtil.isBlank(input)){
            return false;
        }

         Pattern pattern = Pattern.compile(regexStr);
         Matcher matcher = pattern.matcher(input.trim());
         return matcher.matches();
    }

    /**
     * @author 664525
     * 字符串类型转换成为Long类型
     * @param strValue
     * @param defualValue 如果转换失败返回的默认值
     * @return
     */
    public static Long string2Long(String strValue,Long defualValue) {

        Long retValue = null;
        try{
            retValue = Long.parseLong(strValue);
        }catch(Exception e){
            retValue = defualValue;
            logger.error(ExceptionUtils.extractStackTrace(e));
        }
        return retValue;
    }
    /**
     * @author 664525
     * 字符串类型转换成为int类型
     * @param strValue
     * @param defualValue如果转换失败返回的默认值
     * @return
     */
    public static Integer string2Int(String strValue,Integer defualValue) {

        Integer retValue = null;
        try{
            retValue = Integer.parseInt(strValue);
        }catch(Exception e){
            retValue = defualValue;
            logger.error(ExceptionUtils.extractStackTrace(e));
        }
        return retValue;
    }
    /**
     * @author 664525
     * 将int类型转换为Long类型
     * @param num
     * @return
     */
    public static Long int2Long(Integer num) {

        if (BlankUtil.isBlank(num)) {
            return null;
        } else {
            return num.longValue();
        }
    }

    /**
     * @author 664525
     * 将double类型转换成为Long类型
     * @param num
     * @return
     */
    public static Long double2Long(Double num) {

        if (BlankUtil.isBlank(num)) {
            return null;
        } else {
            return num.longValue();
        }
    }

    /**
     * 将String类型转换成为Double类型
     * @param num
     * @return
     */
    public static Double string2Double(String num) {

        if (BlankUtil.isBlank(num)) {
            return null;
        } else {
            try {
                return Double.parseDouble(num);
            } catch (NumberFormatException e) {
                logger.error(ExceptionUtils.extractStackTrace(e));
                return null;
            }
        }
    }
    
    /**
     * 将String类型转换成为double类型,为null或空字符串或报错时，返回0
     * @param num
     * @return
     * @author 80002088
     */
    public static double string2double(String num){
    	if (BlankUtil.isBlank(num)) {
            return 0;
        } else {
            try {
                return Double.parseDouble(num);
            } catch (NumberFormatException e) {
                logger.error(ExceptionUtils.extractStackTrace(e));
                return 0;
            }
        }
    }
    
    /**
     * Long 和 Long类型的数值比较
     * @param num
     * @return
     */
    public static boolean isEqualValue(Long value1,Long value2) {

        if(!BlankUtil.isBlank(value1)&&!BlankUtil.isBlank(value2)){
            return value1.intValue()==value2.intValue();
        }else{
            return BlankUtil.isBlank(value1)&&BlankUtil.isBlank(value2);
        }
    }    
    /**
     * 将Integer类型和Integer类型的比较
     * @param num
     * @return
     */
    public static boolean isEqualValue(Integer value1,Integer value2) {

        if(!BlankUtil.isBlank(value1)&&!BlankUtil.isBlank(value2)){
            return value1.intValue()==value2.intValue();
        }else{
            return BlankUtil.isBlank(value1)&&BlankUtil.isBlank(value2);
        }
    }
    /**
     * 将Double类型和Double类型的比较
     * @author 828513
     * @date 2015-12-18
     */
    public static boolean isEqualValue(Double value1,Double value2) {
        
        if(!BlankUtil.isBlank(value1)&&!BlankUtil.isBlank(value2)){
            BigDecimal v1=BigDecimal.valueOf(value1);
            BigDecimal v2=BigDecimal.valueOf(value2);
            return v1==v2;
        }else{
            return BlankUtil.isBlank(value1)&&BlankUtil.isBlank(value2);
        }
    }
    
    /**
     * 将String类型和Integer类型的比较
     * @param num
     * @return
     */
    public static boolean isEqualValue(String value1,Integer value2) {
        
        try{
            if(!BlankUtil.isBlank(value1)&&!BlankUtil.isBlank(value2)){
                return value2.toString().equals(value1);
            }else{
                return BlankUtil.isBlank(value1)&&BlankUtil.isBlank(value2);
            }
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return false;
        }
    }
    
    /**
     * 如果参数为空，返回0
     * 不空就返回本身
     * @param value
     * @return
     */
    public static Double getNotNullValue(Double value){
        return BlankUtil.isBlank(value) ? 0d : value;
    }
    /**
     * 将String类型和Integer类型的比较
     * @param num
     * @return
     */
    public static Double addDoubleType(Double value1,Double value2) {
        
        try{
            if(value1==null){
                value1 = 0D;
            }
            if(value2==null){
                value2=0D;
            }
            return value1+value2;
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }
    
    /**
     * 将Double类型转BigDecimal类型
     * @param num
     * @return
     */
    public static BigDecimal numberToBigDecimal(Double value1) {
        
        try{
            return value1==null?null:BigDecimal.valueOf(value1);
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }
    /**
     * 将Double类型转BigDecimal类型
     * @param num
     * @return
     */
    public static BigDecimal numberToBigDecimal(Long value1) {
        
        try{
            return value1==null?null:BigDecimal.valueOf(value1);
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }
    /**
     * 将Double类型转BigDecimal类型
     * @param num
     * @return
     */
    public static BigDecimal numberToBigDecimal(Integer value1) {
        
        try{
            return value1==null?null:BigDecimal.valueOf(value1);
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }    
    /**
     * 将Long类型转换成为Integer类型
     * @param val
     * @return
     */
    public static Integer longToInteger(Long val){        
        try{
            if(val==null){
                return null;
            }else{
                return val.intValue();
            }
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }
    /**
     * 将Integer类型转换成为Long类型
     * @param val
     * @return
     */
    public static Long integerToLong(Integer val){        
        try{
            if(val==null){
                return null;
            }else{
                return val.longValue();
            }
        }catch(Exception e){
            logger.error(ExceptionUtils.extractStackTrace(e));
            return null;
        }
    }
    
    /**
     * 将String类型转换成为Long类型
     * @param num
     * @return
     */
    public static Long string2Long(String num) {

        if (BlankUtil.isBlank(num)) {
            return null;
        } else {
            try {
                return Long.parseLong(num);
            } catch (NumberFormatException e) {
                logger.error(ExceptionUtils.extractStackTrace(e));
                return null;
            }
        }
    }
    /**
     * 将Integer类型转换成为Double类型
     * @param num
     * @return
     */
    public static Double integer2Double(Integer num) {

        if (BlankUtil.isBlank(num)) {
            return null;
        } else {
            try {
                return num.doubleValue();
            } catch (Exception e) {
                logger.error(ExceptionUtils.extractStackTrace(e));
                return null;
            }
        }
    }
    
    /**
     * 将Integer类型转换成为Double类型
     * @param num
     * @return
     */
    public static Long BigDecimal2Long(BigDecimal bigDecimal) {

        if (BlankUtil.isBlank(bigDecimal)) {
            return null;
        } else {
            try {
                return bigDecimal.longValue();
            } catch (Exception e) {
                logger.error(ExceptionUtils.extractStackTrace(e));
                return null;
            }
        }
    }
    
    /**
     * 保留double类型的的小数位数,四舍五入    
     * @param value 小数
     * @return
     * @author 80002088
     * 2016年12月7日
     */
    public static Double formatDoubleDecimal(Double value){
        if(value!=null){
            return Double.valueOf(String.format("%.2f", value));
        }
        return null;
    }

    /**
     * 判断是否为数字
     * 
     * @param type
     * @return boolean
     * @author 879149
     * @date 2016年2月25日
     */
    public static boolean isNumeric(String str) {
        Pattern pattern = Pattern.compile("[0-9]*");
        return pattern.matcher(str).matches();
    }

    /**
     * 判断是否为浮点数，包括double和float
     * 
     * @param str
     *            传入的字符串
     * @return 是浮点数返回true,否则返回false
     * @author 879149
     * @date 2016年2月25日
     */
    public static boolean isDouble(String str) {
        Pattern pattern = Pattern.compile("^[-\\+]?[.\\d]*$");
        return pattern.matcher(str).matches();
    }

    /**
     * 判断是否为整数或者浮点数 若满足上面一个条件，就为真
     * 
     * @param str
     *            传入的字符串
     * @return boolean
     * @author 879149
     * @date 2016年2月25日
     */
    public static boolean isNumber(String str) {
        Pattern intNumber = Pattern.compile("[0-9]*");
        Pattern doubleNumber = Pattern.compile("^[-\\+]?[.\\d]*$");
        return (intNumber.matcher(str).matches() || doubleNumber.matcher(str).matches());
    }

    /**
     * Srtring转INT String必须为DOUBLE数值
     * 
     * @param str
     *            传入的字符串
     * @return int
     * @author 879149
     * @date 2016年3月8日
     */
    public static int convertStr2Int(String value) {
        if (value.indexOf(".") > -1) {
            String strVal = String.valueOf(value);
            return Integer.parseInt(strVal.substring(0, strVal.indexOf(".")));
        }
        return Integer.parseInt(value);
    }

    /**
     * @Description 校验是否为数据字
     * @Param
     * @Date 2016年3月12日
     * @Author 879149
     * @Return
     */
    public static boolean isCheckNumber(Object obj) {
        if (obj != null) {
            String data = obj2String(obj);
            if (StringUtils.isNotEmpty(data) && NumberUtil.isNumber(data)) {
                return true;
            }
        }
        return false;
    }

    /**
     * @Description OBJCT对象转为字符串
     * @Param
     * @Date 2016年3月14日
     * @Author 879149
     * @Return String
     */
    public static String obj2String(Object obj) {
        if (obj != null) {
            return String.valueOf(obj).trim();
        }
        return "";
    }

    /**
     * @Description 以逗号分隔将String对象转为数组
     * @Param
     * @Date 2016年3月14日
     * @Author 879149
     * @Return String
     */
    public static String[] string2Array(Object obj) {
        String[] ss=null;
        if (obj != null) {
            ss=String.valueOf(obj).trim().replace("，", ",").split(",");
        }
        return ss;
    }

    /**
     * @Description 字符串去空格
     * @Param
     * @Date 2016年8月31日
     * @Author 879149
     * @Return String
     */
    public static String StringTrim(String val) {
        if (null != val && StringUtils.isNotEmpty(val)) {
            return val.trim();
        }
        return val;
    }

    /**
     * @Description 将一个字符串转换成一个Long类型的数字
     * @Param
     * @Date 2016年9月29日
     * @Return 字符串不为空并且是整数，返回Long类型的数字，其他的返回0
     */
    public static Long convertValueLong(String value) {
        if (StringUtils.isNotEmpty(value) && isNumeric(value)) {
            return Long.parseLong(value);
        } else {
            return 0L;
        }
    }

    /**
     * @Description 将一个字符串转换成一个Long类型的数字
     * @Param
     * @Date 2016年9月29日
     * @Return 字符串不为空并且是整数，返回Long类型的数字，其他的返回0
     */
    public static Integer convertValueInteger(String value) {
        if (StringUtils.isNotEmpty(value) && isNumeric(value)) {
            return Integer.parseInt(value);
        } else {
            return 0;
        }
    }

    /**
     * @Description:生成随机数
     * @Param
     * @Date 2016年12月12日
     * @Author 879149
     * @Return int
     */
    public static int randomNum(int num) {
        return (int) (Math.random() * num + 1);
    }
    
    /**
     * BigDecimal转换为Double
     * @param num
     * @return  num为null时返回null
     * @author 80002031-2017年9月20日
     */
    public static Double big2Double(BigDecimal num){
        if (null != num){
            return Double.parseDouble(num.toString());
        } 
        return null;
    }
    
    /**
     * long 转换为Double
     * @param num
     * @return num为null时返回null
     * @author 80002031-2017年9月20日
     */
    public static Double long2Double(Long num){
        if (null != num){
            return Double.parseDouble(String.valueOf(num));
        }
        return null;
    }
    
    /**
     * 字符串转Double，转不过的返回null
     * @param str
     * @return
     * @author 80002088
     * 2017年9月27日
     */
    public static Double strConvertDouble(String str){
        try {
            if(StringUtil.isStrNotNull(str)){
                return Double.valueOf(str);
            }
        } catch (Exception e) {
            logger.warn("string convert to double warn,str:{},message:{}", str, e);
        }
        return null;
    }
}
